#ifndef __OCPP_Cesium_Math_H__
#define __OCPP_Cesium_Math_H__

#include "CesiumDef.h"

#pragma warning(disable : 4293)

namespace OCPP
{
	namespace Cesium
	{
		class _CesiumExport CesiumMath
		{
		public:
			CesiumMath() {};

			inline const static double M_LOG2E_ = 1.44269504088896340736;

			inline const static double EPSILON1 = 0.1;

			/**
			 * 0.01
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON2 = 0.01;

			/**
			 * 0.001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON3 = 0.001;

			/**
			 * 0.0001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON4 = 0.0001;

			/**
			 * 0.00001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON5 = 0.00001;

			/**
			 * 0.000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON6 = 0.000001;

			/**
			 * 0.0000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON7 = 0.0000001;

			/**
			 * 0.00000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON8 = 0.00000001;

			/**
			 * 0.000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON9 = 0.000000001;

			/**
			 * 0.0000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON10 = 0.0000000001;

			/**
			 * 0.00000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON11 = 0.00000000001;

			/**
			 * 0.000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON12 = 0.000000000001;

			/**
			 * 0.0000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON13 = 0.0000000000001;

			/**
			 * 0.00000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON14 = 0.00000000000001;

			/**
			 * 0.000000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON15 = 0.000000000000001;

			/**
			 * 0.0000000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON16 = 0.0000000000000001;

			/**
			 * 0.00000000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON17 = 0.00000000000000001;

			/**
			 * 0.000000000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON18 = 0.000000000000000001;

			/**
			 * 0.0000000000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON19 = 0.0000000000000000001;

			/**
			 * 0.00000000000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON20 = 0.00000000000000000001;

			/**
			 * 0.000000000000000000001
			 * @type {number}
			 * @constant
			 */
			inline const static double EPSILON21 = 0.000000000000000000001;

			/**
			 * The gravitational parameter of the Earth in meters cubed
			 * per second squared as defined by the WGS84 model: 3.986004418e14
			 * @type {number}
			 * @constant
			 */
			inline const static double GRAVITATIONALPARAMETER = 3.986004418e14;

			/**
			 * Radius of the sun in meters: 6.955e8
			 * @type {number}
			 * @constant
			 */
			inline const static double SOLAR_RADIUS = 6.955e8;

			/**
			 * The mean radius of the moon, according to the "Report of the IAU/IAG Working Group on
			 * Cartographic Coordinates and Rotational Elements of the Planets and satellites: 2000",
			 * Celestial Mechanics 82: 83-110, 2002.
			 * @type {number}
			 * @constant
			 */
			inline const static double LUNAR_RADIUS = 1737400.0;

			/**
			 * 64 * 1024
			 * @type {number}
			 * @constant
			 */
			inline const static double SIXTY_FOUR_KILOBYTES = 64 * 1024;

			/**
			 * 4 * 1024 * 1024 * 1024
			 * @type {number}
			 * @constant
			 */
			inline const static size_t FOUR_GIGABYTES = 4U * 1024 * 1024 * 1024;

			/**
			 * pi
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double PI = float(4.0 * atan(1.0));

			/**
			 * 1/pi
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double ONE_OVER_PI = 1.0 / PI;

			/**
			 * pi/2
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double PI_OVER_TWO = PI / 2.0;

			/**
			 * pi/3
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double PI_OVER_THREE = PI / 3.0;

			/**
			 * pi/4
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double PI_OVER_FOUR = PI / 4.0;

			/**
			 * pi/6
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double PI_OVER_SIX = PI / 6.0;

			/**
			 * 3pi/2
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double THREE_PI_OVER_TWO = (3.0 * PI) / 2.0;

			/**
			 * 2pi
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double TWO_PI = 2.0 * PI;

			/**
			 * 1/2pi
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double ONE_OVER_TWO_PI = 1.0 / (2.0 * PI);

			/**
			 * The number of radians in a degree.
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double RADIANS_PER_DEGREE = PI / 180.0;

			/**
			 * The number of degrees in a radian.
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double DEGREES_PER_RADIAN = 180.0 / PI;

			/**
			 * The number of radians in an arc second.
			 *
			 * @type {number}
			 * @constant
			 */
			inline const static double RADIANS_PER_ARCSECOND = RADIANS_PER_DEGREE / 3600.0;

			/**
			 * Returns the sign of the value; 1 if the value is positive, -1 if the value is
			 * negative, or 0 if the value is 0.
			 *
			 * @function
			 * @param {number} value The value to return the sign of.
			 * @returns {number} The sign of value.
			 */
			static int sign(double value)
			{
				if (value == 0 || value != value)
				{
					// zero or NaN
					return value;
				}
				return value > 0 ? 1 : -1;
			}

			/**
			 * Returns 1.0 if the given value is positive or zero, and -1.0 if it is negative.
			 * This is similar to {@link CesiumMath#sign} except that returns 1.0 instead of
			 * 0.0 when the input value is 0.0.
			 * @param {number} value The value to return the sign of.
			 * @returns {number} The sign of value.
			 */
			double signNotZero(double value)
			{
				return value < 0.0 ? -1.0 : 1.0;
			};

			/**
			 * Converts a scalar value in the range [-1.0, 1.0] to a SNORM in the range [0, rangeMaximum]
			 * @param {number} value The scalar value in the range [-1.0, 1.0]
			 * @param {number} [rangeMaximum=255] The maximum value in the mapped range, 255 by default.
			 * @returns {number} A SNORM value, where 0 maps to -1.0 and rangeMaximum maps to 1.0.
			 *
			 * @see double fromSNorm
			 */
			double toSNorm(double value, double rangeMaximum = 255)
			{
				return round(
					(clamp(value, -1.0, 1.0) * 0.5 + 0.5) * rangeMaximum);
			}

			/**
			 * Converts a SNORM value in the range [0, rangeMaximum] to a scalar in the range [-1.0, 1.0].
			 * @param {number} value SNORM value in the range [0, rangeMaximum]
			 * @param {number} [rangeMaximum=255] The maximum value in the SNORM range, 255 by default.
			 * @returns {number} Scalar in the range [-1.0, 1.0].
			 *
			 * @see double toSNorm
			 */
			double fromSNorm(double value, double rangeMaximum = 255)
			{
				return (
					(clamp(value, 0.0, rangeMaximum) / rangeMaximum) * 2.0 - 1.0);
			}

			/**
			 * Converts a scalar value in the range [rangeMinimum, rangeMaximum] to a scalar in the range [0.0, 1.0]
			 * @param {number} value The scalar value in the range [rangeMinimum, rangeMaximum]
			 * @param {number} rangeMinimum The minimum value in the mapped range.
			 * @param {number} rangeMaximum The maximum value in the mapped range.
			 * @returns {number} A scalar value, where rangeMinimum maps to 0.0 and rangeMaximum maps to 1.0.
			 */
			double normalize(double value, double rangeMinimum, double rangeMaximum)
			{
				rangeMaximum = (std::max)(rangeMaximum - rangeMinimum, 0.0);
				return rangeMaximum == 0.0
						   ? 0.0
						   : clamp((value - rangeMinimum) / rangeMaximum, 0.0, 1.0);
			}

			/**
			 * Returns the hyperbolic sine of a number.
			 * The hyperbolic sine of <em>value</em> is defined to be
			 * (<em>e<sup>x</sup>&nbsp;-&nbsp;e<sup>-x</sup></em>)/2.0
			 * where <i>e</i> is Euler's number, approximately 2.71828183.
			 *
			 * <p>Special cases:
			 *   <ul>
			 *     <li>If the argument is NaN, then the result is NaN.</li>
			 *
			 *     <li>If the argument is infinite, then the result is an infinity
			 *     with the same sign as the argument.</li>
			 *
			 *     <li>If the argument is zero, then the result is a zero with the
			 *     same sign as the argument.</li>
			 *   </ul>
			 *</p>
			 *
			 * @function
			 * @param {number} value The number whose hyperbolic sine is to be returned.
			 * @returns {number} The hyperbolic sine of <code>value</code>.
			 */
			// eslint-disable-next-line es/no-math-sinh
			double sinh(double value)
			{
				return (exp(value) - exp(-value)) / 2.0;
			}

			/**
			 * Returns the hyperbolic cosine of a number.
			 * The hyperbolic cosine of <strong>value</strong> is defined to be
			 * (<em>e<sup>x</sup>&nbsp;+&nbsp;e<sup>-x</sup></em>)/2.0
			 * where <i>e</i> is Euler's number, approximately 2.71828183.
			 *
			 * <p>Special cases:
			 *   <ul>
			 *     <li>If the argument is NaN, then the result is NaN.</li>
			 *
			 *     <li>If the argument is infinite, then the result is positive infinity.</li>
			 *
			 *     <li>If the argument is zero, then the result is 1.0.</li>
			 *   </ul>
			 *</p>
			 *
			 * @function
			 * @param {number} value The number whose hyperbolic cosine is to be returned.
			 * @returns {number} The hyperbolic cosine of <code>value</code>.
			 */
			// eslint-disable-next-line es/no-math-cosh
			double cosh(double value)
			{
				return (exp(value) + exp(-value)) / 2.0;
			}

			/**
			 * Computes the linear interpolation of two values.
			 *
			 * @param {number} p The start value to interpolate.
			 * @param {number} q The end value to interpolate.
			 * @param {number} time The time of interpolation generally in the range <code>[0.0, 1.0]</code>.
			 * @returns {number} The linearly interpolated value.
			 *
			 * @example
			 * const n = Cesium.Math.lerp(0.0, 2.0, 0.5 // returns 1.0
			 */
			static double lerp(double p, double q, double time)
			{
				return (1.0 - time) * p + time * q;
			}

			static double toRadians(double degrees)
			{
				return degrees * RADIANS_PER_DEGREE;
			};

			/**
			 * Converts radians to degrees.
			 * @param {number} radians The angle to convert in radians.
			 * @returns {number} The corresponding angle in degrees.
			 */
			static double toDegrees(double radians)
			{
				return radians * DEGREES_PER_RADIAN;
			};

			/**
			 * Converts a longitude value, in radians, to the range [<code>-Math.PI</code>, <code>Math.PI</code>).
			 *
			 * @param {number} angle The longitude value, in radians, to convert to the range [<code>-Math.PI</code>, <code>Math.PI</code>).
			 * @returns {number} The equivalent longitude value in the range [<code>-Math.PI</code>, <code>Math.PI</code>).
			 *
			 * @example
			 * // Convert 270 degrees to -90 degrees longitude
			 * const longitude = Cesium.Math.convertLongitudeRange(Cesium.Math.toRadians(270.0));
			 */
			static double convertLongitudeRange(double angle)
			{
				double twoPi = TWO_PI;

				double simplified = angle - floor(angle / twoPi) * twoPi;

				if (simplified < -PI)
				{
					return simplified + twoPi;
				}
				if (simplified >= PI)
				{
					return simplified - twoPi;
				}

				return simplified;
			};

			/**
			 * Convenience function that clamps a latitude value, in radians, to the range [<code>-Math.PI/2</code>, <code>Math.PI/2</code>).
			 * Useful for sanitizing data before use in objects requiring correct range.
			 *
			 * @param {number} angle The latitude value, in radians, to clamp to the range [<code>-Math.PI/2</code>, <code>Math.PI/2</code>).
			 * @returns {number} The latitude value clamped to the range [<code>-Math.PI/2</code>, <code>Math.PI/2</code>).
			 *
			 * @example
			 * // Clamp 108 degrees latitude to 90 degrees latitude
			 * const latitude = Cesium.Math.clampToLatitudeRange(Cesium.Math.toRadians(108.0));
			 */
			static double clampToLatitudeRange(double angle)
			{
				return clamp(
					angle,
					-1 * PI_OVER_TWO,
					PI_OVER_TWO);
			};

			/**
			 * Produces an angle in the range -Pi <= angle <= Pi which is equivalent to the provided angle.
			 *
			 * @param {number} angle in radians
			 * @returns {number} The angle in the range [<code>-static double PI</code>, <code>static double PI</code>].
			 */
			static double negativePiToPi(double angle)
			{
				if (angle >= -PI && angle <= PI)
				{
					// Early exit if the input is already inside the range. This avoids
					// unnecessary math which could introduce floating point error.
					return angle;
				}
				return zeroToTwoPi(angle + PI) - PI;
			};

			/**
			 * Produces an angle in the range 0 <= angle <= 2Pi which is equivalent to the provided angle.
			 *
			 * @param {number} angle in radians
			 * @returns {number} The angle in the range [0, <code>static double TWO_PI</code>].
			 */
			static double zeroToTwoPi(double angle)
			{
				if (angle >= 0 && angle <= TWO_PI)
				{
					// Early exit if the input is already inside the range. This avoids
					// unnecessary math which could introduce floating point error.
					return angle;
				}
				double mod1 = mod(angle, TWO_PI);
				if (
					abs(mod1) < EPSILON14 &&
					abs(angle) > EPSILON14)
				{
					return TWO_PI;
				}
				return mod1;
			};

			/**
			 * The modulo operation that also works for negative dividends.
			 *
			 * @param {number} m The dividend.
			 * @param {number} n The divisor.
			 * @returns {number} The remainder.
			 */
			static double mod(long m, long n)
			{
				assert(n != 0);

				//>>includeEnd('debug');
				if (sign(m) == sign(n) && abs(m) < abs(n))
				{
					// Early exit if the input does not need to be modded. This avoids
					// unnecessary math which could introduce floating point error.
					return m;
				}

				return ((m % n) + n) % n;
			};

			/**
			 * Determines if two values are equal using an absolute or relative tolerance test. This is useful
			 * to avoid problems due to roundoff error when comparing floating-point values directly. The values are
			 * first compared using an absolute tolerance test. If that fails, a relative tolerance test is performed.
			 * Use this test if you are unsure of the magnitudes of left and right.
			 *
			 * @param {number} left The first value to compare.
			 * @param {number} right The other value to compare.
			 * @param {number} [relativeEpsilon=0] The maximum inclusive delta between <code>left</code> and <code>right</code> for the relative tolerance test.
			 * @param {number} [absoluteEpsilon=relativeEpsilon] The maximum inclusive delta between <code>left</code> and <code>right</code> for the absolute tolerance test.
			 * @returns {boolean} <code>true</code> if the values are equal within the epsilon; otherwise, <code>false</code>.
			 *
			 * @example
			 * const a = Cesium.Math.equalsEpsilon(0.0, 0.01, Cesium.Math.EPSILON2); // true
			 * const b = Cesium.Math.equalsEpsilon(0.0, 0.1, Cesium.Math.EPSILON2);  // false
			 * const c = Cesium.Math.equalsEpsilon(3699175.1634344, 3699175.2, Cesium.Math.EPSILON7); // true
			 * const d = Cesium.Math.equalsEpsilon(3699175.1634344, 3699175.2, Cesium.Math.EPSILON9); // false
			 */
			static double equalsEpsilon(
				double left,
				double right,
				double relativeEpsilon = 0.0,
				double absoluteEpsilon = 0.0)
			{
				double absDiff = abs(left - right);
				return (
					absDiff <= absoluteEpsilon ||
					absDiff <= relativeEpsilon * (std::max)(abs(left), abs(right)));
			};

			/**
			 * Determines if the left value is less than the right value. If the two values are within
			 * <code>absoluteEpsilon</code> of each other, they are considered equal and this function returns false.
			 *
			 * @param {number} left The first number to compare.
			 * @param {number} right The second number to compare.
			 * @param {number} absoluteEpsilon The absolute epsilon to use in comparison.
			 * @returns {boolean} <code>true</code> if <code>left</code> is less than <code>right</code> by more than
			 *          <code>absoluteEpsilon<code>. <code>false</code> if <code>left</code> is greater or if the two
			 *          values are nearly equal.
			 */
			static double lessThan(double left, double right, double absoluteEpsilon)
			{
				return left - right < -absoluteEpsilon;
			};

			/**
			 * Determines if the left value is less than or equal to the right value. If the two values are within
			 * <code>absoluteEpsilon</code> of each other, they are considered equal and this function returns true.
			 *
			 * @param {number} left The first number to compare.
			 * @param {number} right The second number to compare.
			 * @param {number} absoluteEpsilon The absolute epsilon to use in comparison.
			 * @returns {boolean} <code>true</code> if <code>left</code> is less than <code>right</code> or if the
			 *          the values are nearly equal.
			 */
			static double lessThanOrEquals(double left, double right, double absoluteEpsilon)
			{
				return left - right < absoluteEpsilon;
			};

			/**
			 * Determines if the left value is greater the right value. If the two values are within
			 * <code>absoluteEpsilon</code> of each other, they are considered equal and this function returns false.
			 *
			 * @param {number} left The first number to compare.
			 * @param {number} right The second number to compare.
			 * @param {number} absoluteEpsilon The absolute epsilon to use in comparison.
			 * @returns {boolean} <code>true</code> if <code>left</code> is greater than <code>right</code> by more than
			 *          <code>absoluteEpsilon<code>. <code>false</code> if <code>left</code> is less or if the two
			 *          values are nearly equal.
			 */
			static double greaterThan(double left, double right, double absoluteEpsilon)
			{
				return left - right > absoluteEpsilon;
			};

			/**
			 * Determines if the left value is greater than or equal to the right value. If the two values are within
			 * <code>absoluteEpsilon</code> of each other, they are considered equal and this function returns true.
			 *
			 * @param {number} left The first number to compare.
			 * @param {number} right The second number to compare.
			 * @param {number} absoluteEpsilon The absolute epsilon to use in comparison.
			 * @returns {boolean} <code>true</code> if <code>left</code> is greater than <code>right</code> or if the
			 *          the values are nearly equal.
			 */
			static double greaterThanOrEquals(double left, double right, double absoluteEpsilon)
			{
				return left - right > -absoluteEpsilon;
			};

			inline static std::vector<size_t> factorials = {1};

			/**
			 * Computes the factorial of the provided number.
			 *
			 * @param {number} n The number whose factorial is to be computed.
			 * @returns {number} The factorial of the provided number or undefined if the number is less than 0.
			 *
			 * @exception {DeveloperError} A number greater than or equal to 0 is required.
			 *
			 *
			 * @example
			 * //Compute 7!, which is equal to 5040
			 * const computedFactorial = Cesium.Math.factorial(7);
			 *
			 * @see {@link http://en.wikipedia.org/wiki/Factorial|Factorial on Wikipedia}
			 */
			static size_t factorial(size_t n)
			{
				size_t length = factorials.size();
				if (n >= length)
				{
					size_t sum = factorials[length - 1];
					for (size_t i = length; i <= n; i++)
					{
						size_t next = sum * i;
						factorials.push_back(next);
						sum = next;
					}
				}
				return factorials[n];
			};

			/**
			 * Increments a number with a wrapping to a minimum value if the number exceeds the maximum value.
			 *
			 * @param {number} [n] The number to be incremented.
			 * @param {number} [maximumValue] The maximum incremented value before rolling over to the minimum value.
			 * @param {number} [minimumValue=0.0] The number reset to after the maximum value has been exceeded.
			 * @returns {number} The incremented number.
			 *
			 * @exception {DeveloperError} Maximum value must be greater than minimum value.
			 *
			 * @example
			 * const n = Cesium.Math.incrementWrap(5, 10, 0); // returns 6
			 * const m = Cesium.Math.incrementWrap(10, 10, 0); // returns 0
			 */
			static double incrementWrap(double n, double maximumValue, double minimumValue = 0.0)
			{
				assert(maximumValue <= minimumValue);
				++n;
				if (n > maximumValue)
				{
					n = minimumValue;
				}
				return n;
			};

			/**
			 * Determines if a non-negative integer is a power of two.
			 * The maximum allowed input is (2^32)-1 due to 32-bit bitwise operator limitation in Javascript.
			 *
			 * @param {number} n The integer to test in the range [0, (2^32)-1].
			 * @returns {boolean} <code>true</code> if the number if a power of two; otherwise, <code>false</code>.
			 *
			 * @exception {DeveloperError} A number between 0 and (2^32)-1 is required.
			 *
			 * @example
			 * const t = Cesium.Math.isPowerOfTwo(16); // true
			 * const f = Cesium.Math.isPowerOfTwo(20); // false
			 */
			static bool isPowerOfTwo(int n)
			{
				//>>includeStart('debug', pragmas.debug);
				// if (typeof n != "number" || n < 0 || n > 4294967295) {
				//    throw new DeveloperError("A number between 0 and (2^32)-1 is required.");
				//}
				//>>includeEnd('debug');

				return n != 0 && (n & (n - 1)) == 0;
			};

			/**
			 * Computes the next power-of-two integer greater than or equal to the provided non-negative integer.
			 * The maximum allowed input is 2^31 due to 32-bit bitwise operator limitation in Javascript.
			 *
			 * @param {number} n The integer to test in the range [0, 2^31].
			 * @returns {number} The next power-of-two integer.
			 *
			 * @exception {DeveloperError} A number between 0 and 2^31 is required.
			 *
			 * @example
			 * const n = Cesium.Math.nextPowerOfTwo(29); // 32
			 * const m = Cesium.Math.nextPowerOfTwo(32); // 32
			 */
			static int nextPowerOfTwo(int n)
			{
				--n;
				n |= n >> 1;
				n |= n >> 2;
				n |= n >> 4;
				n |= n >> 8;
				n |= n >> 16;
				++n;

				return n;
			};

			/**
			 * Computes the previous power-of-two integer less than or equal to the provided non-negative integer.
			 * The maximum allowed input is (2^32)-1 due to 32-bit bitwise operator limitation in Javascript.
			 *
			 * @param {number} n The integer to test in the range [0, (2^32)-1].
			 * @returns {number} The previous power-of-two integer.
			 *
			 * @exception {DeveloperError} A number between 0 and (2^32)-1 is required.
			 *
			 * @example
			 * const n = Cesium.Math.previousPowerOfTwo(29); // 16
			 * const m = Cesium.Math.previousPowerOfTwo(32); // 32
			 */
			static unsigned long previousPowerOfTwo(unsigned long n)
			{
				// n |= n >> 1;
				// n |= n >> 2;
				// n |= n >> 4;
				// n |= n >> 8;
				// n |= n >> 16;
				// n |= n >> 32;

				// // The previous bitwise operations implicitly convert to signed 32-bit. Use `>>>` to convert to unsigned
				// n = (n >> 0) - (n >> 1);

				if (sizeof(unsigned long) * 8 == 32)
				{
					n |= n >> 1;
					n |= n >> 2;
					n |= n >> 4;
					n |= n >> 8;
					n |= n >> 16;
					// 32位的情况下不执行右移32位的操作
				}
				// 如果unsigned long是64位的
				else if (sizeof(unsigned long) * 8 == 64)
				{
					n |= n >> 1;
					n |= n >> 2;
					n |= n >> 4;
					n |= n >> 8;
					n |= n >> 16;
					n |= n >> 32;
					n |= n >> 48; // 针对64位的情况补充处理
				}

				// 正确的无符号右移
				n = (n >> 0) - (n >> 1);

				return n;
			};

			/**
			 * Constraint a value to lie between two values.
			 *
			 * @param {number} value The value to clamp.
			 * @param {number} min The minimum value.
			 * @param {number} max The maximum value.
			 * @returns {number} The clamped value such that min <= result <= max.
			 */
			static double clamp(double value, double min, double max)
			{
				return value < min ? min : value > max ? max
													   : value;
			};

			/**
			 * Sets the seed used by the random number generator
			 * in {@link CesiumMath#nextRandomNumber}.
			 *
			 * @param {number} seed An integer used as the seed.
			 */
			static double setRandomNumberSeed(double seed)
			{
				return std::rand();
			};

			/**
			 * Generates a random floating point number in the range of [0.0, 1.0)
			 * using a Mersenne twister.
			 *
			 * @returns {number} A random number in the range of [0.0, 1.0).
			 *
			 * @see static double setRandomNumberSeed
			 * @see {@link http://en.wikipedia.org/wiki/Mersenne_twister|Mersenne twister on Wikipedia}
			 */
			static double nextRandomNumber()
			{
				return std::rand();
			};

			/**
			 * Generates a random number between two numbers.
			 *
			 * @param {number} min The minimum value.
			 * @param {number} max The maximum value.
			 * @returns {number} A random number between the min and max.
			 */
			static double randomBetween(double min, double max)
			{
				return nextRandomNumber() * (max - min) + min;
			};

			/**
			 * Computes <code>Math.acos(value)</code>, but first clamps <code>value</code> to the range [-1.0, 1.0]
			 * so that the function will never return NaN.
			 *
			 * @param {number} value The value for which to compute acos.
			 * @returns {number} The acos of the value if the value is in the range [-1.0, 1.0], or the acos of -1.0 or 1.0,
			 *          whichever is closer, if the value is outside the range.
			 */
			static double acosClamped(double value)
			{
				return acos(clamp(value, -1.0, 1.0));
			};

			/**
			 * Computes <code>Math.asin(value)</code>, but first clamps <code>value</code> to the range [-1.0, 1.0]
			 * so that the function will never return NaN.
			 *
			 * @param {number} value The value for which to compute asin.
			 * @returns {number} The asin of the value if the value is in the range [-1.0, 1.0], or the asin of -1.0 or 1.0,
			 *          whichever is closer, if the value is outside the range.
			 */
			static double asinClamped(double value)
			{
				return asin(clamp(value, -1.0, 1.0));
			};

			/**
			 * Finds the chord length between two points given the circle's radius and the angle between the points.
			 *
			 * @param {number} angle The angle between the two points.
			 * @param {number} radius The radius of the circle.
			 * @returns {number} The chord length.
			 */
			static double chordLength(double angle, double radius)
			{
				return 2.0 * radius * sin(angle * 0.5);
			};

			/**
			 * Finds the logarithm of a number to a base.
			 *
			 * @param {number} number The number.
			 * @param {number} base The base.
			 * @returns {number} The result.
			 */
			static double logBase(double number, double base)
			{
				return log(number) / log(base);
			};

			/**
			 * Finds the cube root of a number.
			 * Returns NaN if <code>number</code> is not provided.
			 *
			 * @function
			 * @param {number} [number] The number.
			 * @returns {number} The result.
			 */
			// eslint-disable-next-line es/no-math-cbrt
			static double cbrt(double number)
			{
				double result = pow(abs(number), 1.0 / 3.0);
				return number < 0.0 ? -result : result;
			}

			/**
			 * Finds the base 2 logarithm of a number.
			 *
			 * @function
			 * @param {number} number The number.
			 * @returns {number} The result.
			 */
			// eslint-disable-next-line es/no-math-log2
			static double log2(double number)
			{
				return log(number) * M_LOG2E_;
			}

			/**
			 * @private
			 */
			static double fog(double distanceToCamera, double density)
			{
				double scalar = distanceToCamera * density;
				return 1.0 - exp(-(scalar * scalar));
			};

			/**
			 * Computes a fast approximation of Atan for input in the range [-1, 1].
			 *
			 * Based on Michal Drobot's approximation from ShaderFastLibs,
			 * which in turn is based on "Efficient approximations for the arctangent function,"
			 * Rajan, S. Sichun Wang Inkol, R. Joyal, A., May 2006.
			 * Adapted from ShaderFastLibs under MIT License.
			 *
			 * @param {number} x An input number in the range [-1, 1]
			 * @returns {number} An approximation of atan(x)
			 */
			static double fastApproximateAtan(double x)
			{
				return x * (-0.1784 * abs(x) - 0.0663 * x * x + 1.0301);
			};

			/**
			 * Computes a fast approximation of Atan2(x, y) for arbitrary input scalars.
			 *
			 * Range reduction math based on nvidia's cg reference implementation: http://developer.download.nvidia.com/cg/atan2.html
			 *
			 * @param {number} x An input number that isn't zero if y is zero.
			 * @param {number} y An input number that isn't zero if x is zero.
			 * @returns {number} An approximation of atan2(x, y)
			 */
			static double fastApproximateAtan2(double x, double y)
			{
				double opposite;
				double t = abs(x); // t used as swap and atan result.
				opposite = abs(y);
				double adjacent = (std::max)(t, opposite);
				opposite = (std::min)(t, opposite);

				double oppositeOverAdjacent = opposite / adjacent;
				//>>includeStart('debug', pragmas.debug);
				// if (isNaN(oppositeOverAdjacent)) {
				//    throw new DeveloperError("either x or y must be nonzero");
				//}
				//>>includeEnd('debug');
				t = fastApproximateAtan(oppositeOverAdjacent);

				// Undo range reduction
				t = abs(y) > abs(x) ? PI_OVER_TWO - t : t;
				t = x < 0.0 ? PI - t : t;
				t = y < 0.0 ? -t : t;
				return t;
			};

			static inline bool isNaN(double f)
			{
				// std::isnan() is C99, not supported by all compilers
				// However NaN always fails this next test, no other number does.
				return f != f;
			}
		};
	}
}

#endif
